home *** CD-ROM | disk | FTP | other *** search
/ Gekikoh Dennoh Club 5 / Gekikoh Dennoh Club Vol. 5 (Japan).7z / Gekikoh Dennoh Club Vol. 5 (Japan) (Track 01).bin / internet / xip / iijppp.lzh / src / ccp.c < prev    next >
C/C++ Source or Header  |  1994-10-11  |  6KB  |  280 lines
  1. /*
  2.  *       PPP Compression Control Protocol (CCP) Module
  3.  *
  4.  *        Written by Toshiharu OHNO (tony-o@iij.ad.jp)
  5.  *
  6.  *   Copyright (C) 1994, Internet Initiative Japan, Inc. All rights reserverd.
  7.  *
  8.  * Redistribution and use in source and binary forms are permitted
  9.  * provided that the above copyright notice and this paragraph are
  10.  * duplicated in all such forms and that any documentation,
  11.  * advertising materials, and other materials related to such
  12.  * distribution and use acknowledge that the software was developed
  13.  * by the Internet Initiative Japan, Inc.  The name of the
  14.  * IIJ may not be used to endorse or promote products derived
  15.  * from this software without specific prior written permission.
  16.  * THIS SOFTWARE IS PROVIDED ``AS IS'' AND WITHOUT ANY EXPRESS OR
  17.  * IMPLIED WARRANTIES, INCLUDING, WITHOUT LIMITATION, THE IMPLIED
  18.  * WARRANTIES OF MERCHANTIBILITY AND FITNESS FOR A PARTICULAR PURPOSE.
  19.  *
  20.  *    TODO:
  21.  *        o Support other compression protocols
  22.  */
  23. #include "fsm.h"
  24. #include "lcpproto.h"
  25. #include "lcp.h"
  26. #include "ccp.h"
  27. #include "phase.h"
  28. #include "vars.h"
  29.  
  30. extern void PutConfValue();
  31.  
  32. struct ccpstate CcpInfo;
  33.  
  34. static void CcpSendConfigReq(struct fsm *);
  35. static void CcpSendTerminateReq(struct fsm *fp);
  36. static void CcpSendTerminateAck(struct fsm *fp);
  37. static void CcpDecodeConfig(struct mbuf *bp, int mode);
  38. static void CcpLayerStart(struct fsm *);
  39. static void CcpLayerFinish(struct fsm *);
  40. static void CcpLayerUp(struct fsm *);
  41. static void CcpLayerDown(struct fsm *);
  42. static void CcpInitRestartCounter(struct fsm *);
  43.  
  44. #define    REJECTED(p, x)    (p->his_reject & (1<<x))
  45.  
  46. struct fsm CcpFsm = {
  47.   "CCP",
  48.   PROTO_CCP,
  49.   CCP_MAXCODE,
  50.   OPEN_ACTIVE,
  51.   ST_INITIAL,
  52.   0, 0, 0,
  53.  
  54.   0,
  55.   { 0, 0, 0, NULL, NULL, NULL },
  56.  
  57.   CcpLayerUp,
  58.   CcpLayerDown,
  59.   CcpLayerStart,
  60.   CcpLayerFinish,
  61.   CcpInitRestartCounter,
  62.   CcpSendConfigReq,
  63.   CcpSendTerminateReq,
  64.   CcpSendTerminateAck,
  65.   CcpDecodeConfig,
  66. };
  67.  
  68. static char *cftypes[] = {
  69. /*  0 */  "OUI",    "PRED1", "PRED2", "PUDDLE",
  70. /*  4 */  "???",    "???",   "???",   "???",
  71. /*  8 */  "???",    "???",   "???",   "???",
  72. /* 12 */  "???",    "???",   "???",   "???",
  73. /* 16 */  "HWPPC",  "STAC",  "MSPPC", "GAND",
  74. /* 20 */  "V42BIS", "BSD",
  75. };
  76.  
  77. void
  78. ReportCcpStatus()
  79. {
  80.   struct ccpstate *icp = &CcpInfo;
  81.   struct fsm *fp = &CcpFsm;
  82.  
  83.   printf("%s [%s]\n", fp->name, StateNames[fp->state]);
  84.   printf("myproto = %s, hisproto = %s\n",
  85.     cftypes[icp->want_proto], cftypes[icp->his_proto]);
  86.   printf("Input: %d --> %d,  Output: %d --> %d\n",
  87.     icp->orgin, icp->compin, icp->orgout, icp->compout);
  88. }
  89.  
  90. void
  91. CcpInit()
  92. {
  93.   struct ccpstate *icp = &CcpInfo;
  94.  
  95.   FsmInit(&CcpFsm);
  96.   bzero(icp, sizeof(struct ccpstate));
  97.   if (Enabled(ConfPred1))
  98.     icp->want_proto = TY_PRED1;
  99.   CcpFsm.maxconfig = 10;
  100. }
  101.  
  102. static void
  103. CcpInitRestartCounter(fp)
  104. struct fsm *fp;
  105. {
  106.   fp->FsmTimer.load = 3 * SECTICKS;
  107.   fp->restart = 5;
  108. }
  109.  
  110. static void
  111. CcpSendConfigReq(fp)
  112. struct fsm *fp;
  113. {
  114.   u_char *cp;
  115.   struct ccpstate *icp = &CcpInfo;
  116.  
  117.   cp = ReqBuff;
  118.   LogPrintf(LOG_LCP, "%s: SendConfigReq\n", fp->name);
  119.   if (icp->want_proto && !REJECTED(icp, TY_PRED1)) {
  120.     *cp++ = TY_PRED1; *cp++ = 2;
  121.   }
  122.   FsmOutput(fp, CODE_CONFIGREQ, fp->reqid++, ReqBuff, cp - ReqBuff);
  123. }
  124.  
  125. void
  126. CcpSendResetReq(fp)
  127. struct fsm *fp;
  128. {
  129.   Pred1Init(1);        /* Initialize Input part */
  130.   LogPrintf(LOG_LCP, "%s: SendResetReq\n", fp->name);
  131.   FsmOutput(fp, CODE_RESETREQ, fp->reqid, NULL, 0);
  132. }
  133.  
  134. static void
  135. CcpSendTerminateReq(fp)
  136. struct fsm *fp;
  137. {
  138.   /* XXX: No code yet */
  139. }
  140.  
  141. static void
  142. CcpSendTerminateAck(fp)
  143. struct fsm *fp;
  144. {
  145.   LogPrintf(LOG_LCP, "  %s: SendTerminateAck\n", fp->name);
  146.   FsmOutput(fp, CODE_TERMACK, fp->reqid++, NULL, 0);
  147. }
  148.  
  149. void
  150. CcpRecvResetReq(fp)
  151. struct fsm *fp;
  152. {
  153.   Pred1Init(2);        /* Initialize Output part */
  154. }
  155.  
  156. static void
  157. CcpLayerStart(fp)
  158. struct fsm *fp;
  159. {
  160.   LogPrintf(LOG_LCP, "%s: LayerStart.\n", fp->name);
  161. }
  162.  
  163. static void
  164. CcpLayerFinish(fp)
  165. struct fsm *fp;
  166. {
  167.   LogPrintf(LOG_LCP, "%s: LayerFinish.\n", fp->name);
  168. }
  169.  
  170. static void
  171. CcpLayerDown(fp)
  172. struct fsm *fp;
  173. {
  174.   LogPrintf(LOG_LCP, "%s: LayerDown.\n", fp->name);
  175. }
  176.  
  177. /*
  178.  *  Called when CCP has reached to OPEN state
  179.  */
  180. static void
  181. CcpLayerUp(fp)
  182. struct fsm *fp;
  183. {
  184. #ifdef VERBOSE
  185.   fprintf(stderr, "%s: LayerUp(%d).\r\n", fp->name, fp->state);
  186. #endif
  187.   LogPrintf(LOG_LCP, "%s: LayerUp.\n", fp->name);
  188.   LogPrintf(LOG_LCP, "myproto = %d, hisproto = %d\n",
  189.     CcpInfo.want_proto, CcpInfo.his_proto);
  190.   Pred1Init(3);        /* Initialize Input and Output */
  191. }
  192.  
  193. void
  194. CcpUp()
  195. {
  196.   FsmUp(&CcpFsm);
  197.   LogPrintf(LOG_LCP, "CCP Up event!!\n");
  198. }
  199.  
  200. void
  201. CcpOpen()
  202. {
  203.   if (Enabled(ConfPred1))
  204.     FsmOpen(&CcpFsm);
  205. }
  206.  
  207. static void
  208. CcpDecodeConfig(bp, mode)
  209. struct mbuf *bp;
  210. int mode;
  211. {
  212.   u_char *cp;
  213.   int plen, type, length;
  214.   u_long *lp, compproto;
  215.   struct compreq *pcomp;
  216.   struct in_addr ipaddr, dstipaddr;
  217.   char tbuff[100];
  218.  
  219.   plen = plength(bp);
  220.  
  221.   cp = MBUF_CTOP(bp);
  222.   ackp = AckBuff;
  223.   nakp = NakBuff;
  224.   rejp = RejBuff;
  225.  
  226.   while (plen >= sizeof(struct fsmconfig)) {
  227.     if (plen < 0)
  228.       break;
  229.     type = *cp;
  230.     length = cp[1];
  231.     if (type <= TY_BSD)
  232.       sprintf(tbuff, " %s[%d] ", cftypes[type], length);
  233.     else
  234.       sprintf(tbuff, " ");
  235.  
  236.     LogPrintf(LOG_LCP, "%s\n", tbuff);
  237.  
  238.     switch (type) {
  239.     case TY_PRED1:
  240.       switch (mode) {
  241.       case MODE_REQ:
  242.     if (Acceptable(ConfPred1)) {
  243.       bcopy(cp, ackp, length);
  244.       ackp += length;
  245.       CcpInfo.his_proto = type;
  246.     } else {
  247.       bcopy(cp, rejp, length);
  248.       rejp += length;
  249.     }
  250.     break;
  251.       case MODE_NAK:
  252.       case MODE_REJ:
  253.     CcpInfo.his_reject |= (1 << type);
  254.     CcpInfo.want_proto = 0;
  255.     break;
  256.       }
  257.       break;
  258.     case TY_BSD:
  259.     default:
  260.       CcpInfo.my_reject |= (1 << type);
  261.       bcopy(cp, rejp, length);
  262.       rejp += length;
  263.       break;
  264.     }
  265.     plen -= length;
  266.     cp += length;
  267.   }
  268. }
  269.  
  270. void
  271. CcpInput(struct mbuf *bp)
  272. {
  273.   if (phase == PHASE_NETWORK)
  274.     FsmInput(&CcpFsm, bp);
  275.   else {
  276.     logprintf("ccp in phase %d\n", phase);
  277.     pfree(bp);
  278.   }
  279. }
  280.